Instance 0

Class330.getBuggleImage(Color c)#1{
      for (int dx=0; dx<13; dx++) 
        if (SPRITE[dy][dx] == 1) 
          g.fill(new Rectangle2D.Double(dx*10, dy*10, 10,10));
}


Instance 1

Class450.paintObject(Graphics2D g2,State s,ObjectInstance ob,float cWidth,float cHeight)#0{
      int building = ob.getIntValForAttribute(FrostbiteDomain.BUILDINGATTNAME);
      for (; layer < Math.min(maxLayer, building) - 1; layer++) {
        if (layer == maxLayer / 3) {
          brickHeight /= 2;
          iglooOffsety = -(layer - 1) * brickHeight;
        }
        if (layer >= maxLayer / 3) {
          iglooWidth -= FrostbiteDomain.gameWidth / (4 * maxLayer);
          iglooOffsetx += FrostbiteDomain.gameWidth / (8 * maxLayer);
        }
        g2.fill(new Rectangle2D.Double(iglooOffsetx + 3 * FrostbiteDomain.gameWidth / 4,
            iglooOffsety + FrostbiteDomain.gameHeight / 5 - brickHeight * layer,
            iglooWidth, brickHeight));
      }
      if (building >= maxLayer) {
        g2.setColor(Color.black);
        int doorWidth = FrostbiteDomain.gameWidth / 28;
        int doorHeight = FrostbiteDomain.gameHeight / 20;
        g2.fill(new Rectangle2D.Double(3 * FrostbiteDomain.gameWidth / 4 + FrostbiteDomain.gameWidth / 12 - doorWidth / 2,
            FrostbiteDomain.gameHeight / 5 - doorHeight/2, doorWidth, doorHeight));
      }
}


Instance 2

Class400.highlightPivot(Graphics2D g,MapView mv,EastNorth pivot)#0{
        Shape pvCentrePoint = new Ellipse2D.Double(
                mv.getPoint(pivot).getX() - 5.0f,
                mv.getPoint(pivot).getY() - 5.0f, 10.0f, 10.0f);
        g.fill(pvCentrePoint);
        Shape pvPoint = new Ellipse2D.Double(mv.getPoint(pivot).getX() - 8.0f,
                mv.getPoint(pivot).getY() - 8.0f, 16.0f, 16.0f);
        g.draw(pvPoint);
}


Instance 3

Class750.doPaint(Graphics2D g2,Object o,int i,int i1)#1{
        RoundRectangle2D rect = new RoundRectangle2D.Double(0, 0, c.getWidth() - 1, c.getHeight() - 1, 24, 24);
        g2.fill(rect);
        Ellipse2D ellipse = new Ellipse2D.Double(-c.getWidth(),
                c.getHeight() / 3.0, c.getWidth() * 3.0,
                c.getHeight() * 2.0);
        Area area = new Area(new Rectangle(0, 0, c.getWidth(), c.getHeight()));
        area.subtract(new Area(ellipse));
        area.intersect(new Area(rect));
}


Instance 4

Class170.paintComponent(Graphics g)#1{
    g2.fill(new Rectangle2D.Double(0., 0., getWidth(), getHeight()));
    double ratio = Math.min(((double) getWidth()) / renderedX, ((double) getHeight()) / renderedY);
    g2.translate(Math.abs(getWidth() - ratio * renderedX)/2., Math.abs(getHeight() - ratio * renderedY)/2.);
    g2.scale(ratio, ratio);
}


Instance 5

Class380.paintComponentState(Graphics g)#5{
    g2.fill(new Rectangle2D.Double(0.,0.,(double)getWidth(),(double)getHeight()));
}


Instance 6

Class630.paintComponent(Graphics g)#3{
    g2.fill(new Rectangle2D.Double(0., 0., (double) tw.getWidth()*LightBotWorldView2D.CELL_WIDTH, (double) tw.getHeight()*LightBotWorldView2D.CELL_WIDTH));
    drawWorld2D(g2);
}


Instance 7

Class410.paintImage(Graphics2D g,Image im,Point2D s[],int offsety)#5{
      if (s[i].empty() == false)
        g.fill(new Ellipse2D.Double(s[i].x * factor - 1, s[i].y * factor - 1 + offsety, 3, 3));
}


Instance 8

Class230.drawBuggle(Graphics2D g,AbstractBuggle b)#4{
          int direction = b.getDirection().intValue();
          if (INVADER_SPRITE[direction][dy][dx] == 1) {
            g.fill(new Rectangle2D.Double(padx+pad+ox+dx*pixW, pady+pad+oy+dy*pixW, pixW, pixW));
          }
}


Instance 9

Class400.paint(Graphics2D g,double xOffset,double yOffset,int markerSize)#0{
    double halfSize = (double) markerSize / 2;
    Shape circle = new Ellipse2D.Double(xOffset - halfSize, yOffset - halfSize, markerSize, markerSize);
    g.fill(circle);
}


Instance 10

Class520.paint(Graphics2D g,double factor,int xOffset,int yOffset,boolean dotSelection,String control1,String control2,String control3)#13{
    for (int i = 0; i < spotcnt; i++)
      g.fill(new Rectangle2D.Double(spots[i].x * factor - 1 + xOffset, spots[i].y * factor - 1 + yOffset, 3, 3));
}


Instance 11

Class550.paintComponent(Graphics g)#0{
            for (Map.Entry<Packet.Sensor, Integer> entry : packet.getSensors().entrySet()) {
                double y = 20 * (entry.getValue() - offset) / 2048.0;
                Shape shape = new Rectangle.Double(x, y + 15 * entry.getKey().ordinal(), 2, 2);
                g2.fill(shape);
            }
}


Instance 12

Class520.paint(Graphics2D g,double factor,int xOffset,int yOffset,boolean dotSelection,String control1,String control2,String control3)#1{
      g.drawOval((int) (refPoint1.x * factor) - 10 + xOffset, (int) (refPoint1.y * factor) - 10 + yOffset, 20, 20);
      g.fill(new Rectangle2D.Double((refPoint1.x * factor) - 1 + xOffset, (refPoint1.y * factor) - 1 + yOffset, 3, 3));
}


Instance 13

Class520.paint(Graphics2D g,double factor,int xOffset,int yOffset,boolean dotSelection,String control1,String control2,String control3)#8{
      g.drawOval((int) (refPoint3.x * factor) - 10 + xOffset, (int) (refPoint3.y * factor) - 10 + yOffset, 20, 20);
      g.fill(new Rectangle2D.Double(refPoint3.x * factor - 1 + xOffset, refPoint3.y * factor - 1 + yOffset, 3, 3));
}


Instance 14

Class520.paint(Graphics2D g,double factor,int xOffset,int yOffset,boolean dotSelection,String control1,String control2,String control3)#0{
      g.drawOval((int) (refPoint2.x * factor) - 10 + xOffset, (int) (refPoint2.y * factor) - 10 + yOffset, 20, 20);
      g.fill(new Rectangle2D.Double(refPoint2.x * factor - 1 + xOffset, refPoint2.y * factor - 1 + yOffset, 3, 3));
}


Instance 15

Class670.paintBackground(Graphics g,JComponent component)#0{
      final RoundRectangle2D rectangleRounded = new RoundRectangle2D.Double(
          0, 0, getWidth() * 2, getHeight(), 8, 8);
      g2D.fill(rectangleRounded);
}


Instance 16

Class670.paintBackground(Graphics g,JComponent component)#1{
      final RoundRectangle2D rectangleRounded = new RoundRectangle2D.Double(
          0, 0, getWidth(), getHeight() * 2, 8, 8);
      g2D.fill(rectangleRounded);
}


Instance 17

Class750.createDragAndDropCursor()#1{
            Rectangle2D.Double rect = new Rectangle2D.Double(0, 0, width, height);
            g.fill(rect);
                    dragNDropImage.createGraphics();
}


Instance 18

Class60.createHandCursor()#3{
            Rectangle2D.Double rect = new Rectangle2D.Double(0, 0, 32, 32);
            g.fill(rect);
            g = handImage.createGraphics();
}


Instance 19

Class250.paintDecoration(final Graphics2D g,final Graphics2D gstroke,final double x0,final double y0,final double x1,final double y1,double dx,double dy,double dxn,double dyn){
    final double middleDistanceToConvexHull = getDistanceToConvexHull();
      final double distanceToConvexHull = middleDistanceToConvexHull * 2.2 * random(0.7);
    final Shape shape = new QuadCurve2D.Double(x0, y0, xctrl, yctrl, x1, y1);
    g.fill(shape);
    gstroke.draw(shape);
}


Instance 20

Class340.drawBackground(Graphics2D g)#5{
        g.fill(new Rectangle2D.Double(padx+x*cellW, pady+y*cellW, cellW, cellW));  
}


Instance 21

Class330.drawBot2D(Graphics2D g,LightBotEntity bot)#2{
    g.fill(new Arc2D.Double((cx - 0.25) * CELL_WIDTH - cell.getHeight() * CELL_HEIGHT, (cy + 0.1) * CELL_WIDTH
        - cell.getHeight() * CELL_HEIGHT, 1.5 * width, 1.5 * height, 60, 60, Arc2D.PIE));
    g.rotate(-angle, rx, ry);
}


Instance 22

Class290.executeDrawOperation()#7{
            graphics.fill(new Arc2D.Double(stroke_width, stroke_width,
                width, height, start, stop, type));
}


Instance 23

Class30.paintObject(Graphics2D g2,State s,ObjectInstance ob,float cWidth,float cHeight)#1{
      int size = fd.getAgentSize();
      g2.fill(new Rectangle2D.Double(x, y, size, size));
}


Instance 24

Class670.drawLight2D(Graphics2D g,GridWorldCell cell,boolean lightOn)#3{
    g.fill(new Arc2D.Double(cell.getX()*LightBotWorldView2D.CELL_WIDTH + 0.1*LightBotWorldView2D.CELL_WIDTH, cell.getY()*LightBotWorldView2D.CELL_WIDTH + 0.1*LightBotWorldView2D.CELL_WIDTH, 0.8*LightBotWorldView2D.CELL_WIDTH, 0.8*LightBotWorldView2D.CELL_WIDTH, 0, 360, Arc2D.OPEN));
}


Instance 25

Class670.executeDrawOperation()#6{
            graphics.fill(new Ellipse2D.Double(0, 0, width, height));
}


Instance 26

Class450.paintObject(Graphics2D g2,State s,ObjectInstance ob,float cWidth,float cHeight)#0{
      double xr = (lld.getXmax() - lld.getXmin());
      double yr = (lld.getYmax() - lld.getYmin());
      double nl = (ol - lld.getXmin()) / xr;
      double nt = (ot - lld.getYmin()) / yr;
      g2.fill(new Rectangle2D.Double(sx, sy, sw, sh));
}


Instance 27

Class450.paintObject(Graphics2D g2,State s,ObjectInstance ob,float cWidth,float cHeight)#1{
        g2.fill(new Rectangle2D.Double(3 * FrostbiteDomain.gameWidth / 4 + FrostbiteDomain.gameWidth / 12 - doorWidth / 2,
            FrostbiteDomain.gameHeight / 5 - doorHeight/2, doorWidth, doorHeight));
}


Instance 28

Class640.drawFill(Graphics2D g){
        new Ellipse2D.Double(ellipse.getCenterX()-POINT_SIZE, 
                  ellipse.getCenterY()-POINT_SIZE, 
                  POINT_SIZE*2, POINT_SIZE*2);
    g.fill(newEllipse);
    drawText(g);
}


Instance 29

Class280.drawSlot(Graphics2D g2,int rank,double xoffset)#6{
    g2.fill(new Rectangle2D.Double(xoffset-2, 35.,  2., 145.));
}


Instance 30

Class610.drawVertex(Graphics2D g2d,PaintContext context,double x,double y){
    g2d.fill(new Rectangle2D.Double(x - 5.0 / scale,
        y - 5.0 / scale, 10.0 / scale, 10.0 / scale));
}


Instance 31

Class180.paint(Graphics2D g2)#1{
            g2.fill(new Ellipse2D.Double(point[0] - ts / 2,
                                        point[1] - ts / 2,
                                        ts,
                                        ts));
}


Instance 32

Class380.paintObject(Graphics2D g2,State s,ObjectInstance ob,float cWidth,float cHeight)#0{
      g2.fill(new Rectangle2D.Double(sx, sy, renderAgentWidth, renderAgentWidth));
}


Instance 33

Class530.paintComponent(Graphics oldG)#1{
    g.fill(new Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}


Instance 34

Class460.paintComponent(Graphics g)#0{
        Ellipse2D.Double circle = new Ellipse2D.Double(0, 0, current_bounds.width, current_bounds.height);
        g2d.fill(circle);
}


Instance 35

Class460.drawWeightRectangle(Graphics2D newSpace,DataTable dataTable,int column,double maxWeight,int plotterSize)#2{
            weightRect = new Rectangle2D.Double(weightBorder, weightBorder, plotterSize - 2 * weightBorder, plotterSize - 2 * weightBorder);
            newSpace.fill(weightRect);
}


Instance 36

Class50.paint(Graphics2D g2d)#3{
            g2d.fill(new Ellipse2D.Double(s.from.getX() - 1, s.from.getY() - 1, 2, 2));
}


Instance 37

Class90.paintComponent(Graphics g)#0{
    g2.fill(new Rectangle2D.Double(0., 0., renderedX, renderedY));
}


Instance 38

Class70.paintComponent(Graphics g)#0{
                g2d.fill(new Ellipse2D.Double(150, 150, 70, 70));
}


Instance 39

Class510.paintSelection(Graphics2D g2d)#1{
                    g2d.fill ( new RoundRectangle2D.Double ( rect.x + selectionShadeWidth, rect.y + selectionShadeWidth,
                            rect.width - selectionShadeWidth * 2 - 1, rect.height - selectionShadeWidth * 2 - 1, 0,
                            0 ) );
}


Instance 40

Class570.paintComponent(Graphics g)#1{
    RoundRectangle2D rect = new RoundRectangle2D.Double(0, 0, width - 1, height - 1, 0, 0);
    g2.fill(rect);
}


Instance 41

Class210.getGCCompatibleImage(int width,int height)#2{
        Rectangle2D.Double rect = new Rectangle2D.Double(0, 0, width, height);
        g2D.fill(rect);
}


Instance 42

Class400.paint(Graphics2D g2,State s,float cWidth,float cHeight)#0{
        g2.fill(new Rectangle2D.Double(0, 0, FrostbiteDomain.gameWidth, FrostbiteDomain.gameIceHeight));
}


Instance 43

Class250.paintIcon(Component c,Graphics g,int x,int y)#1{
            new Ellipse2D.Double(x + getIconWidth() - JBUI.scale(iSize), y + getIconHeight() - iSize, iSize, iSize);
          g2d.fill(shape);
}


Instance 44

Class620.drawBot2D(Graphics2D g,LightBotEntity bot)#2{
    g.fill(new Arc2D.Double((cx-0.25)*LightBotWorldView2D.CELL_WIDTH,(cy+0.1)*LightBotWorldView2D.CELL_WIDTH,1.5*width,1.5*height,60,60, Arc2D.PIE));    
}


Instance 45

Class240.drawRectLatLon(Graphics2D g,int color,double lon1,double lat1,double lon2,double lat2)#1{
        Rectangle2D.Double r = new Rectangle2D.Double(r2.getX(), r2.getY(), r2.getWidth(), r2.getHeight());
        g.fill(r);
}


Instance 46

Class240.paintComponent(Graphics g)#1{
            new Ellipse2D.Double(0,0,getWidth(),getHeight());
         g2d.fill(ellipse);
}


Instance 47

Class680.paintComponent(Graphics graphics)#2{
            Shape rect = new RoundRectangle2D.Double(
                    lineWidth/2d + getInsets().left,
                    lineWidth/2d + getInsets().top,
                    getWidth() - lineWidth/2d - getInsets().left - getInsets().right,
                    getHeight() - lineWidth/2d - getInsets().top - getInsets().bottom,
                    20, 20);
            g.fill(rect);
}


Instance 48

Class300.paintImage(Graphics2D g2d,Color color1,Color color2,Color color3)#1{
        g2d.fill(new Ellipse2D.Double(0, 0, dim, dim));
}


Instance 49

Class190.paintComponent(Graphics g)#1{
               new Ellipse2D.Double(-10,-10,20,20);
            g2d.fill(ellipse);
}